4.02. Стили кода

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВВ РАЗРАБОТКЕ

Разработчику Аналитику Тестировщику
Архитектору Инженеру

Стили кода (Code Style)

Стиль кода — это совокупность соглашений и практик, определяющих внешнее оформление исходного текста программы.

Цель стиля кода — достижение устойчивой читаемости, предсказуемости и поддерживаемости программного кода при коллективной разработке, его долгосрочном сопровождении и передаче между разработчиками. Стиль кода напрямую определяет эффективность восприятия человеком и снижает когнитивную нагрузку при анализе, модификации и отладке.

Стиль кода формируется на основе многолетнего опыта профессиональных сообществ и закрепляется в виде рекомендаций, стандартов и автоматизированных инструментов проверки. Он включает в себя правила форматирования текста, именования сущностей, структурирования логических блоков, организации файлов и модулей, а также приёмы, повышающие понимание намерений автора кода без дополнительных пояснений.

Человеко-читаемость

Человеко-читаемость — центральный принцип стиля кода. Программный код пишется один раз, но читается многократно — при ревью, сопровождении, расширении функциональности, отладке и обучении. Участники разработки тратят значительно больше времени на чтение и интерпретацию существующего кода, чем на написание нового. Поэтому код должен быть организован так, чтобы его структура и поток управления были очевидны уже при первом просмотре.

Высокая человеко-читаемость достигается за счёт последовательного применения одинаковых решений в однотипных ситуациях, использования понятных имен, логической группировки операций, избегания избыточной сложности и поддержания естественного порядка чтения. Код, соответствующий этим требованиям, позволяет быстро выявить суть алгоритма, локализовать ответственность компонентов и предсказать поведение системы без необходимости погружения в детали реализации на раннем этапе анализа.

Определение стиля кода

Стиль кода — это набор правил, регулирующих оформление программного текста. Он применяется на уровне языка, проекта или организации и может включать:

• правила именования переменных, функций, классов, констант и других сущностей;
• соглашения о размещении фигурных скобок, отступов и пустых строк;
• требования к длине строк, переносам и выравниванию;
• рекомендации по структуре файлов, порядку объявлений и группировке логических блоков;
• правила форматирования выражений, вызовов функций и цепочек операций;
• подходы к документированию кода и комментированию.

Стиль кода работает на уровне синтаксического представления. Он упрощает реализацию решений, делая их более прозрачными и последовательными. Стиль кода создаёт предсказуемую среду, в которой разработчик может сосредоточиться на логике задачи, не отвлекаясь на неоднозначности оформления.

В крупных проектах стиль кода фиксируется в виде официального документа — руководства по стилю (Style Guide). Такой документ согласуется командой и поддерживается с помощью автоматизированных инструментов: линтеров, форматтеров, интеграций в систему непрерывной интеграции. Примеры широко распространённых руководств: PEP 8 для Python, Google Java Style Guide, Airbnb JavaScript Style Guide, Microsoft C# Coding Conventions.

Длина строки и переносы

Длина строки — один из ключевых элементов читаемости. Современные стандарты рекомендуют ограничивать длину строки 80–120 символами, в зависимости от контекста и принятых соглашений. Это ограничение связано с физиологическими и техническими факторами. Горизонтальное скольжение при чтении длинных строк утомляет зрение и нарушает естественный ритм восприятия. Многие инструменты — редакторы кода, системы сравнения версий, терминалы, средства код-ревью — оптимизированы под работу с колонками фиксированной ширины.

Переносы строк используются для соблюдения ограничения длины. Переносы выполняются в местах логических разрывов: после запятых в списках аргументов, перед операторами связки (&&, ||, +), после открывающих скобок в многострочных выражениях. При переносе применяется дополнительный уровень отступа, чтобы визуально отделить продолжение строки от нового оператора.

Цель переноса — сохранить ясность структуры, не нарушая семантической целостности выражения.

Многострочное форматирование особенно важно при работе с длинными цепочками вызовов, сложными условными выражениями, декларациями объектов или списков. В таких случаях перенос повышает восприятие иерархии и позволяет быстро выделить ключевые компоненты конструкции.

Организация кода внутри файла

Файл с исходным кодом — базовая единица хранения и передачи знаний в проекте. Его структура должна отражать логическую организацию компонентов и облегчать навигацию.

Хорошо организованный файл начинается с блока метаданных: импортов, директив препроцессора, объявлений зависимостей. Импорты группируются по источнику — стандартная библиотека, сторонние пакеты, локальные модули — и сортируются внутри групп по алфавиту.

После импортов следует основное содержимое файла: классы, функции, константы, вспомогательные структуры.

Порядок объявлений внутри файла подчиняется принципу от общего к частному. Объявления с наибольшей областью видимости и ответственностью размещаются первыми. В объектно-ориентированных языках это означает, что в классе сначала объявляются публичные свойства и методы, затем защищённые, затем приватные. Такой порядок соответствует тому, как разработчик взаимодействует с классом: сначала он сталкивается с его интерфейсом, и только при необходимости погружается в детали реализации.

Логическая группировка дополняет порядок объявлений. Связанные по смыслу элементы размещаются рядом: свойства, инициализируемые в конструкторе, образуют блок; методы, реализующие один сценарий использования, располагаются последовательно; вспомогательные функции, используемые внутри публичного метода, находятся непосредственно после него или в конце класса, если они применяются в нескольких местах.

При обнаружении повторяющихся фрагментов кода в двух и более методах принимается решение о вынесении общего кода в отдельный метод. Такой метод получает осмысленное имя, отражающее его назначение, и размещается в логически подходящем месте — обычно ближе к точкам использования. Вынос общего кода повышает компактность, устраняет дублирование, упрощает тестирование и делает изменения более безопасными.

Близость связанного кода

Близость — принцип размещения кода, при котором элементы, имеющие функциональную связь, находятся физически рядом в тексте программы. Переменные объявляются как можно ближе к первому месту их использования. Это сокращает область их видимости, снижает риск неожиданного изменения значения и делает причинно-следственные связи более очевидными.

Функции и методы, участвующие в одном сценарии, размещаются последовательно. Если одна функция вызывает другую, а та — третью, предпочтительно разместить их в порядке вызова: сначала вызывающая, затем вызываемая. Такой порядок соответствует естественному потоку чтения и минимизирует необходимость прокрутки файла в поисках определения.

Часто используемые фрагменты кода группируются либо по логической цепочке выполнения, либо по принадлежности к единому контексту — например, обработка запроса, валидация, трансформация, сохранение. Такая группировка позволяет рассматривать код как последовательность шагов бизнес-процесса, а не как набор разрозненных операций.

Правило понижения (The Step-down Rule)

Правило понижения — принцип построения последовательности функций и методов внутри файла или класса, согласно которому каждый последующий элемент находится на более низком уровне абстракции, чем предыдущий. Код читается сверху вниз, как повествование: на верхнем уровне представлены высокоуровневые операции, каждая из которых детализируется ниже.

Например, метод processOrder может сначала вызывать validateInput, calculatePrice, persistToDatabase. Определения этих методов следуют сразу после processOrder, причём каждый из них, в свою очередь, может ссылаться на ещё более детализированные подпрограммы — например, calculatePrice вызывает applyDiscount, addTax, roundAmount. Их определения размещаются после calculatePrice.

Такой порядок создаёт иерархию абстракций без необходимости прыжков по файлу. Разработчик, читающий код, сначала видит общую картину, затем по мере продвижения вниз получает всё больше деталей. Это соответствует когнитивной модели пошагового уточнения и значительно ускоряет понимание алгоритма.

Пробелы и операторы

Расстановка пробелов вокруг операторов и ключевых слов — часть визуальной грамматики кода. Пробелы служат разделителями лексем, делая структуру выражений очевидной даже при беглом просмотре. Например, запись x = a + b * c читается быстрее и точнее, чем x=a+b*c, поскольку пробелы визуально отделяют операнды и подчёркивают приоритет операций.

Пробелы ставятся:

• до и после бинарных операторов (=, +, -, *, /, ==, !=, <, >, &&, ||);
• после запятых в списках аргументов и элементов;
• внутри скобок — после открывающей и перед закрывающей, если это повышает читаемость;
• вокруг ключевых слов в управляющих конструкциях (if, for, while, catch), но не внутри вызовов функций;
• между именем функции и открывающей скобкой аргументов — пробел не ставится.

Одиночные операторы (++, --, !) не окружены пробелами, когда используются префиксно или постфиксно. Пробелы не ставятся между именем функции и скобкой вызова, между именем типа и угловыми скобками обобщённого параметра, внутри скобок при доступе к элементу массива или свойству объекта.

Эти правила не связаны с синтаксисом языка — компилятор или интерпретатор игнорирует лишние пробелы. Пробелы — инструмент восприятия. Их последовательное применение делает код более ровным и снижает вероятность визуальных ошибок при чтении.

---

Именование

Имена — основной канал передачи смысла в коде. Хорошо подобранное имя заменяет комментарий, выражает намерение разработчика и связывает программную реализацию с предметной областью. Именование включает выбор слов, их форму, порядок и стиль написания — всё это должно подчиняться единым правилам внутри проекта.

Осмысленность имени означает, что оно точно отражает сущность или действие. Переменная хранит данные — её имя выражает что хранится: customerEmail, invoiceTotal, retryCount. Функция выполняет действие — её имя глагольное и описывает что делает: calculateDiscount, validateForm, serializeToJson. Класс инкапсулирует понятие — его имя существительное: PaymentGateway, UserSession, RateLimiter.

Согласованность требует применения одинаковых шаблонов в однотипных ситуациях. Если в проекте принят стиль camelCase для переменных и функций, а PascalCase — для классов и интерфейсов, отклонения от этого порядка создают когнитивный диссонанс. Если метод, возвращающий логическое значение, именуется с префиксом is, has, can или should, все подобные методы должны следовать этому шаблону: isValid, hasPermission, canRetry, shouldRefresh.

Доменные термины — ключевой элемент именования в бизнес-приложениях. Использование языка предметной области в коде создаёт единое понимание между разработчиками, аналитиками и заказчиками. Если в системе управления логистикой груз называется накладной, а не записью или объектом, то класс именуется Waybill, а не CargoRecord. Термины берутся из глоссария проекта, бизнес-процессов или регламентирующих документов. Это исключает двусмысленность и делает код частью общей модели системы.

Избыточность и сокращения требуют баланса. Имя должно быть достаточно полным, чтобы быть самодостаточным — dateOfBirth предпочтительнее dob, если dob не является устоявшимся акронимом в команде. В то же время, внутри узкого контекста допустимы краткие имена: i, j в циклах; e для исключения в обработчике catch; req, res в middleware веб-фреймворков — при условии, что контекст делает их однозначными.

Комментарии

Комментарии — вспомогательный механизм пояснения кода. Их цель — передать информацию, которую невозможно выразить средствами самого языка программирования: мотивацию принятого решения, ограничения реализации, ссылки на внешние источники, неочевидные побочные эффекты.

Комментарии уместны, когда код не может быть улучшен за счёт переименования, рефакторинга или выноса в отдельную функцию. Например, обходной путь для ошибки в сторонней библиотеке, специфическое требование регулятора, нетривиальный алгоритм, оптимизированный под конкретное оборудование — всё это достойно пояснения.

Форма комментария зависит от его назначения. Пояснительный комментарий размещается перед блоком кода и начинается с заглавной буквы, заканчивается точкой. Он краток, грамматически корректен, избегает разговорных выражений. Заглушающий комментарий (// TODO, // FIXME, // HACK) используется временно и требует отслеживания — такие метки включаются в задачи технического долга.

Комментарии не дублируют код. Запись вида i++; // увеличить i на единицу избыточна. Комментарий должен добавлять новый уровень понимания. Также не комментируют очевидное — например, стандартные шаблоны инициализации, обёртки над API, типовые паттерны.

Документирующие комментарии — особый вид, предназначенный для генерации внешней документации (например, через JSDoc, XML-комментарии в C#, Docstrings в Python). Они описывают контракт: назначение функции, параметры, возвращаемое значение, возможные исключения. Такие комментарии пишутся в строгом формате, проверяются статическими анализаторами и встраиваются в IDE.

Вертикальная и горизонтальная плотность кода

Плотность кода — мера количества смысловой информации, приходящейся на единицу текста. Она бывает вертикальной (по строкам) и горизонтальной (по символам в строке). Оптимальная плотность балансирует между лаконичностью и ясностью.

Вертикальная плотность регулируется пустыми строками. Пустая строка — визуальный разделитель логических блоков. Её отсутствие сливает разнородные операции в единый массив, повышая нагрузку на восприятие. Её избыток фрагментирует связанные действия и нарушает целостность мысли.

Рекомендуется разделять пустой строкой:

• объявления на уровне модуля (импорты, константы, классы);
• логические секции внутри функции (подготовка, основная обработка, финализация);
• группы операторов в длинных методах;
• публичные и приватные члены класса.

Одна пустая строка достаточна. Две и более применяются только для выделения крупных разделов в очень длинных файлах — например, между основными блоками конфигурации или группами тестов.

Горизонтальная плотность управляется длиной выражений, вложенностью и количеством операций в одной строке. Чем больше операций объединено в одну строку, тем выше когнитивная нагрузка. Длинные цепочки вызовов, вложенные тернарные операторы, многоуровневые условные выражения снижают читаемость.

Приём «одна идея — одна строка» помогает снизить горизонтальную плотность. Присваивание результата промежуточной переменной с осмысленным именем делает последующий код понятнее: вместо return validate(parse(normalize(input))) — три строки с normalized = normalize(input), parsed = parse(normalized), return validate(parsed). Это не избыточность, а декомпозиция мышления.

Стиль в функциональных и декларативных парадигмах

Функциональное программирование вносит специфику в стиль кода, связанную с неизменяемостью, композицией функций и отсутствием побочных эффектов. Здесь важны имена функций высшего порядка, порядок аргументов и формат цепочек трансформаций.

В декларативных фреймворках (например, React, Vue, Angular) стиль кода распространяется на структуру компонентов, размещение эффектов, управление состоянием и JSX/шаблонами. Компоненты организуются по принципу одна ответственность — один компонент. Внутри компонента соблюдается порядок: объявление пропсов и типов, хуки в стандартной последовательности (useState, useEffect, useMemo, useCallback), вспомогательные функции, возвращаемый JSX.

JSX-разметка форматируется с отступами, соответствующими иерархии элементов. Атрибуты переносятся при превышении длины строки. Самозакрывающиеся теги используют < />. Логические выражения в условиях (&&, тернарные операторы) выносятся в переменные, если они сложны — это улучшает читаемость и упрощает отладку.

Инструменты обеспечения стиля

Ручное соблюдение стиля кода не масштабируется. Автоматизация — обязательное условие поддержания единообразия в командах. Основные инструменты:

Линтеры анализируют код на соответствие правилам стиля и потенциальным ошибкам. Они работают на уровне AST (абстрактного синтаксического дерева), что позволяет проверять не только форматирование, но и семантические ограничения: неиспользуемые переменные, небезопасные операции, нарушения типов. Примеры: ESLint (JavaScript/TypeScript), Pylint (Python), StyleCop (C#), Checkstyle (Java).

Форматтеры изменяют текст программы для приведения к единому виду без участия разработчика. Они не проверяют логику, а перестраивают пробелы, отступы, переносы. Форматтеры идемпотентны: повторный запуск не меняет результат. Примеры: Prettier (универсальный, особенно популярен для JS/TS/JSX/CSS), Black (Python), clang-format (C/C++/Java), rustfmt (Rust).

Pre-commit хуки — скрипты, запускаемые перед фиксацией изменений в системе контроля версий. Они применяют форматтер, запускают линтер и останавливают коммит при нарушениях. Это гарантирует, что в основную ветку попадает только код, соответствующий стилю.

Интеграция этих инструментов в редактор кода обеспечивает мгновенную обратную связь: подсветка нарушений, автоисправление при сохранении файла. Команды фиксируют конфигурационные файлы (.eslintrc, .prettierrc, pyproject.toml) в репозитории, делая стиль частью кодовой базы.

---

Styled Components

Styled Components — технология, интегрирующая стилизацию непосредственно в компонентную модель, преимущественно в экосистеме React, но с аналогами в других фреймворках (например, Vue Styled Components, Emotion). Она базируется на шаблонных строках JavaScript и генерации уникальных CSS-классов во время выполнения. Стиль кода здесь распространяется не только на логику, но и на представление, что требует дополнительных соглашений.

Ключевой принцип — изоляция стилей компонента. Каждый компонент определяет собственные стили как функцию от пропсов, что обеспечивает переиспользование и предотвращает коллизии имён классов. Именование стилевых компонентов следует тем же правилам, что и для обычных: PascalCase, осмысленное название, отражающее семантику, а не визуальные свойства — PrimaryButton, CardContainer, StatusBadge, а не BlueButton, RoundedDiv.

Внутри стилевого блока сохраняется стандартный CSS-синтаксис с расширениями: вложенные селекторы, псевдоклассы, медиавыражения. Отступы — 2 пробела, как в основном JavaScript-коде проекта. Переносы строк применяются после каждого свойства. Длинные значения (например, градиенты, box-shadow) разбиваются на несколько строк.

Интерполяции (вставки значений из пропсов) оформляются без пробелов вокруг ${ }. Если выражение сложное, его выносят в переменную вне стилевого блока и передают как замыкание. Это сохраняет читаемость шаблона и позволяет повторно использовать логику интерполяции.

Глобальные стили и сбросы (reset/normalize) выносятся в отдельные файлы и подключаются один раз на уровне приложения. Миксинные функции для часто используемых наборов свойств (например, visuallyHidden, truncateText) размещаются в общей директории styles/utils и импортируются по необходимости.

Styled Components не отменяют необходимость архитектуры стилей. Рекомендуются слои:

• базовые токены (цвета, типографика, радиусы, тени) — в theme.ts;
• утилиты и миксины — в mixins.ts;
• стили компонентов — рядом с их реализацией (Button.tsx, Button.styled.ts);

Такая структура делает стиль кода предсказуемым и масштабируемым.

Историческое развитие стилей кода

Стили кода эволюционировали вместе с языками и инструментами. Ранние стандарты формализовали практики, сложившиеся в ограниченных условиях: узкие терминалы (80 символов), отсутствие подсветки синтаксиса, печать листингов на бумаге.

K&R (Kernighan & Ritchie) — стиль, представленный в книге The C Programming Language (1978). Отличается фигурными скобками, где открывающая скобка находится на той же строке, что и заголовок конструкции, а закрывающая — на отдельной строке на уровне заголовка. Отступы — табуляция. Этот стиль стал основой для Java, JavaScript, C++ и других C-подобных языков.

Allman style — альтернатива K&R, где каждая фигурная скобка размещается на отдельной строке. Получил распространение в Windows-экосистеме и стал стандартом для C# (Microsoft). Упрощает визуальное выравнивание блоков, особенно при глубокой вложенности.

GNU style — использует отступ в 2 табуляции для тела функции и 1 табуляцию для вложенных блоков. Отличается высокой вертикальной плотностью. Применяется в проектах GNU, но редко вне них.

Python изначально закрепил отступы как синтаксическую конструкцию (в отличие от фигурных скобок), что сделало стиль кода неотъемлемой частью языка. PEP 8, принятый в 2001 году, систематизировал эти правила и стал образцом для других сообществ.

Современные стандарты учитывают опыт коллективной разработки: появление линтеров (JSLint, 2002), форматтеров (gofmt, 2009), CI/CD-пайплайнов. Акцент сместился с предпочтений на воспроизводимость и автоматизацию. Prettier (2017) продемонстрировал, что споры о стиле можно исключить полностью, если сделать форматирование детерминированным и не настраиваемым.

Когнитивные основы стиля

Стиль кода опирается на принципы когнитивной психологии — науки о том, как человек воспринимает, запоминает и обрабатывает информацию.

Рабочая память ограничена: одновременно человек может удерживать 4–7 элементов. Хороший стиль снижает количество элементов, требующих запоминания: осмысленные имена заменяют комментарии, последовательные отступы визуализируют вложенность, единообразное именование позволяет предсказывать имена новых сущностей.

Эффект привычки (chunking) — способность группировать элементы в блоки на основе опыта. Разработчик, привыкший к определённому порядку объявлений, мгновенно находит конструктор в классе, не сканируя весь текст. Нарушение привычного порядка вызывает когнитивное сопротивление.

Горизонтальное и вертикальное движение глаз — чтение кода отличается от чтения прозы. Глаза совершают движения по Z-образной траектории: сверху вниз, с небольшими возвратами. Длинные строки заставляют совершать горизонтальные саккады, что утомляет. Пустые строки создают визуальные «остановки», позволяя мозгу сгруппировать информацию.

Синтаксическая подсветка и визуальная иерархия — мозг быстрее распознаёт структуру по форме, чем по содержанию. Отступы, пробелы, прописные буквы в именах создают иерархию без дополнительных усилий. Это называется перцептивной группировкой — принципом гештальт-психологии.

Учёт этих механизмов позволяет проектировать стиль кода не как набор формальных правил, а как инструмент когнитивной поддержки.

Стиль кода и коллективная ответственность

Стиль кода тесно связан с моделью ответственности за кодовую базу.

Code Ownership (модель единоличного владения) предполагает, что за каждый модуль отвечает конкретный разработчик. В такой модели стиль кода может варьироваться от модуля к модулю, что снижает общую согласованность. Однако владелец быстро вносит правки и знает все нюансы реализации.

Collective Code Ownership (коллективная ответственность) — принцип, при котором любой участник команды имеет право и обязанность вносить изменения в любой модуль. Эта модель требует строгого и единообразного стиля кода, поскольку иначе переход между участками кода потребует постоянной адаптации к новым соглашениям.

В коллективной модели стиль кода становится частью социального контракта. Он согласуется на этапе планирования, документируется и поддерживается автоматически. Ревью кода включает проверку стиля как обязательный этап — не как формальность, а как вклад в долгосрочную поддерживаемость.

Переход от единоличного к коллективному владению часто сопровождается внедрением форматтеров, унификацией именования и рефакторингом «особенных» модулей. Это инвестиция в гибкость команды: любой разработчик может заменить другого без потери производительности.

Строки и инструкции

Как мы ранее определили, есть интерпретируемость (построчность) и компилируемость кода. Но собственно, что такое строка кода?

Строка кода (code line) — это одна физическая строка в тексте программы. Это аналог строки в книге: вы начинаете слева, пишете код, и заканчиваете справа. В большинстве редакторов каждая такая строка имеет свой номер строки.

Важно - не путайте строку кода с типом данных «Строка» (String)!

Номер строки (line number) — это позиционный идентификатор, который помогает ориентироваться в тексте программы. Он особенно важен:

• При отладке (например, сообщения об ошибках указывают номер строки).
• При чтении кода (можно быстро находить нужные участки).
• При работе в команде (ссылаться на конкретную строку).

К примеру, новичок когда отлаживает код с более опытным программистом, с этим и столкнётся - «у тебя на 176-ой строке ошибка», «поставь точку остановы на строку 243», «перейди на 78-ю строку». В некоторых средах (IDE) нумерация строк включена по умолчанию. В других её нужно включать вручную.

Инструкция (statement) — это минимальная логическая единица программы, которая выполняет какое-то действие. Допустим, объявление функции, присваивание значения переменной, вызов функции. Строка — это физическая часть текста, а инструкция - логическая единица (она может занимать несколько строк).

Иногда одна инструкция может быть разбита на несколько строк для удобства чтения. Это делается через:

• Скобки : (), {}, [] — внутри них можно переходить на новую строку.
• Обратный слэш \ — явный символ продолжения строки.

Некоторые языки позволяют писать несколько инструкций в одной строке, разделяя их точкой с запятой:

x = 5; y = 10; print(x + y)

Три инструкции в одной строке. Но это считается плохим стилем, потому что снижает читаемость. Если разбить на строки, то будет так:

x = 5;
y = 10;
print(x + y)

Регистр

Регистр (case) — это характеристика букв, указывающая, являются ли они заглавными (прописными) или строчными (маленькими). С помощью регистра выполняется различение символов как заглавных (A–Z) или строчных (a–z).

• Заглавные буквы: A, B, C, ..., Z
• Строчные буквы: a, b, c, ..., z К примеру, здесь две разные переменные:

name = "Локи"
Name = "Танос"

В большинстве языков программирования регистр имеет значение, к примеру, C#, Java, JavaScript, Python, C++, Ruby, PHP, Go. То есть:

myVariable != MyVariable != MYVARIABLE != myvariable

Это четыре разные переменные с точки зрения интерпретатора или компилятора.

Есть и регистронезависимые языки, там язык не важен (частично) - SQL, Visual Basic, Pascal. Но даже в них часто рекомендуют придерживаться стиля ради читаемости.

К примеру в SQL:

SELECT name FROM users WHERE NAME = 'Snake';
-- Все эти слова могут быть написаны в любом регистре

Однако в SQL таблицы и столбцы могут быть регистрозависимыми в зависимости от системы управления БД (например, PostgreSQL). Так что тут следует придерживаться соглашений об именовании - о них мы поговорим позже отдельно.

Знаки препинания

Кто-то с детства использует знаки препинания при написании текста (они и становятся хорошистами-отличниками в школе), а кто-то привык писать лениво, не расставляя запятые, а про точку с запятой и вовсе не слышали.

В отличие от естественных языков, где знаки препинания нужны для интонации и пауз, в программировании они служат синтаксическим элементам:

• разделение выражений;
• обозначение блоков;
• работа с данными;
• определение типов.

Запятая (,) разделяет элементы в списке, аргументы функций, параметры. В некоторых языках может использоваться как оператор (например, в C-like языках).

numbers = [1, 2, 3]

Точка (.) используется для обращения к свойствам и методам объектов (что такое объект, мы ещё поговорим). В некоторых языках точка используется как часть чисел с плавающей точкой. Также точка может быть частью импортов или пространств имён.

System.out.println("Привет");
const person = { name: "Snake" };
console.log(person.name);

Кавычки " и ' используются для обрамления строковых литералов (значения переменных в коде). Некоторые языки различают одинарные и двойные кавычки, в других они взаимозаменяемы.

let greeting = "Привет";

В некоторых языках (JavaScript, PHP) двойные кавычки позволяют интерполировать переменные внутри строки. Интерполяция позволяет подставлять значение переменных в текст.

Переменная — это контейнер, в котором хранится значение. Её можно использовать в разных частях программы, в том числе внутри строк. Но в современных языках есть более удобный способ: интерполяция строк. Это возможность вставлять значения переменных прямо внутрь строки, без необходимости конкатенации (+) или вызова функций. Такой синтаксис делает код чище и понятнее.

Обратные кавычки: позволяют создавать многострочные строки и использовать интерполяцию, поддерживают переносы строк, и выражения вставлять очень удобно, к примеру, ${2 + 2}. Вот пример в JavaScript:

let user = "Довакин";
let greeting = `Привет, ${user}!
Как у тебя дела?`;

console.log(greeting);
// Привет, Довакин!
// Как у тебя дела?

PHP не использует $, но поддерживает интерполяцию внутри двойных кавычек:

$name = "Ульфрик";
echo "Привет, $name";  // Привет, Ульфрик

Точка с запятой (;) используется для завершения инструкции. К примеру, в C, C++, Java она обязательна, а в JavaScript не всегда обязательна. В Python и Ruby точка с запятой не нужна, но может использоваться для разделения нескольких инструкций в одной строке.

Двоеточие (:) используется в разных языках по разному для обозначения начала блока, типизации (в языках со статической типизацией) и для срезов (slicing) в некоторых языках. К примеру, TypeScript прямо требует указание типа:

let count: number = 10;
function greet(name: string): void {
    console.log("Hello, " + name);
}

Не игнорируйте знаки препинания — их отсутствие или избыток может привести к ошибкам. Можете изучить стандарты написания кода, чтобы правильно расставлять запятые, но это знаете, штука интуитивная. На практике проще, чем кажется - но новички в основном то путают кавычки, то забывают точку с запятой или запятую, после чего всё и ломается.

Пользуйтесь подсветкой синтаксиса — она поможет увидеть, где вы что написали. Если используете язык с обязательным завершением строк точкой с запятой (Java, C++) — не забывайте её ставить.

Скобки

Скобки — это символы, которые всегда используются парами: открывающая ((, {, [, <) и закрывающая (), }, ], >).

Они служат для группировки выражений, определения блоков кода, объявления структур данных, указания типов или шаблонов, управления приоритетом операций.

Круглые скобки ():

• вызов функций и методов;
• передача параметров;
• изменение порядка выполнения операций;
• создание кортежей.

Это те самые скобки для функции(и, её, параметров). Если вы забудете скобку — это приведёт к синтаксической ошибке, наверняка ещё с математики мы помним правило - скобка открывающая требует закрывающую. Возможно, учителя в начальных классах вам даже дописывали красной ручкой забытую скобку. Так и будет в программировании.

Фигурные скобки {}, как мы уже говорили ранее, обозначают блок кода (тело функции, условия, циклы). Они создают объекты (в JS), создают множества и словари. В Python фигурные скобки не нужны для блоков — вместо них используется отступ. Но к этому опять же, вернёмся. Квадратные скобки [] используются для доступа к элементам по индексу (списки, массивы), срезов, создания списков и массивов, и в некоторых языках для индексации.

Угловые скобки <> представляют собой обобщённые типы (generics), шаблоны (templates), и теги (в HTML/XML).

<p>Это абзац в HTML</p>

// C++: шаблон
std::vector<int> numbers;

// Java: обобщённый тип
List<String> names = new ArrayList<>();

Открывающие и закрывающие скобки — почему важна пара? Каждая открывающая скобка должна иметь соответствующую закрывающую, иначе программа не будет работать - программа будет ожидать, что она всё ещё в скобках, и не воспримет следующую инструкцию.

Не забывайте закрывать скобки — это самая частая ошибка новичков. Редакторы кода часто подсвечивают парные скобки и помогают находить незакрытые. Используйте автоформатирование в редакторе — он поможет расставить скобки правильно. Пишите отступы внутри фигурных скобок — это улучшает читаемость. Разбирайтесь, где какой тип скобок нужен — например, в JSON всегда используются фигурные скобки для объектов. Дуамю, вы ещё освоитесь с такими особенностями.

Специальные символы

Специальные символы — это знаки, которые не являются буквами или цифрами, но имеют семантическое значение в коде. Они могут быть:

• Операторами (+, -, *, /, =, ==, !=, &&, ||)
• Метасимволами (например, _, #, @)
• Частью конструкций : аннотаций, указания типов, условий
• Инструментами для работы с данными

Давайте рассмотрим в форме таблицы.

Символ	Название	Использование	Примеры
_	Подчеркивание	Приватные переменные, игнорирование значений, разделение чисел	int _x; 1_000_000
*	Звёздочка	Умножение, указатель, распаковка, повторение	a * b *ptr "-" * 5
#	Октоторп / решётка	Комментарии (Python), препроцессор (C), метаданные	# комментарий #include <stdio.h>
@	"Собака"	Декораторы (Python), аннотации (Java), email/метки	@decorator @Override
/	Косая черта	Деление, пути файлов, регулярные выражения	5 / 2 path/to/file /regex/
?	Вопросительный знак	Nullable-типы (Kotlin), тернарный оператор, Элвис-оператор	String? name age > 18 ? "ok" : "no"
!	Восклицательный знак	Отрицание, ненулевые значения	if (!valid) value!!
-	Дефис / минус	Вычитание, отрицательные числа, флаги	x = -5, 5 - 3 --verbose
+	Плюс	Сложение, конкатенация	1 + 2, "Hello" + "World"
|	Вертикальная черта	Логическое ИЛИ, пайплайн, разделение типов	a || b
~	Тильда	Побитовое НЕ, деструкторы (C++), домашняя директория	(~user) ~x ~MyClass() ~/Documents
=	Равно	Присваивание, сравнение (==, !=)	x = 5 if (x == 5)
</>	Меньше / Больше	Сравнение, обобщённые типы (generics), HTML/XML	if (a < b) List<String> <div>
&	Амперсанд	Логическое И, ссылки (C++), битовые операции	a && b int& ref flags & mask
%	Процент	Остаток от деления, форматирование строк	5 % 2 "%.2f" % value
$	Доллар	Переменные (Bash), интерполяция (JS), шаблоны	$x ${name} $(ls)

Не все символы одинаково используются во всех языках — всегда уточняйте контекст, поэтому тут важно рассматривать каждый язык отдельно. Узнайте, какие символы часто используются в вашем языке — это поможет читать и писать код быстрее. Пользуйтесь автодополнением в IDE — оно подскажет, что может означать символ. Избегайте перегрузки символов без причины — это снижает читаемость кода.

Экранирование

Экранирование (escaping) — это способ указания, что определённый символ должен интерпретироваться не как обычный текст , а как литерал , либо наоборот, как специальный управляющий символ.

Для этого перед таким символом ставится символ экранирования — чаще всего это обратный слэш \ .

Зачем нужно экранирование?

Потому что некоторые символы уже зарезервированы для выполнения определённых функций - к примеру, кавычки (" и ') обозначают начало и конец строки, а символы \n, \t — это спецсимволы: перенос строки и табуляция. В регулярных выражениях символ . означает «любой символ», но если вы хотите использовать точку буквально — её нужно экранировать.

Примеры экранирования:

print("Он сказал: \"Привет!\"") 
# Результат: Он сказал: "Привет!"
print("Первая строка\nВторая строка")
# \n — это спецсимвол перевода строки
print("C:\\Program Files\\MyApp")  
# Чтобы показать один \, нужно написать \\

Где ещё используется экранирование?

1. URL и пути. Символы вроде пробела, #, & в URL нужно кодировать:

https://example.com/hello  world → https://example.com/hello%20world 

2. JSON / XML / HTML. Нужно экранировать символы <, >, &:

3. Командная строка / Shell - там требуется экранировать кавычки.

Отступы

Отступы (indentation) — это сдвиг текста относительно левого края. Они нужны для улучшения читаемости и определения логических блоков кода (например, тело цикла или условие). В большинстве языков отступы — вопрос стиля, но в Python они часть синтаксиса (к примеру, если убрать отступ в Python после if, то будет ошибка).

блок кода {
    тело <- обратите внимание на оступ;
    ещё один блок кода {
       <-обратите внимание на ещё один отступ;
    }
}

Табуляция (\t) представляет собой один символ, который говорит «Сделай отступ». Это клавиша Tab. Длина отступа зависит от настройки среды (часто 4 или 8 пробелов) - внешне это выглядит как один большой пробел.

Пробелы, в отличие от табуляции, являются литералом - каждый пробел будет отдельным символом. Они используются, чтобы контролировать размер отступа.

В проекте нужно выбирать один стиль - часто рекомендуют использовать четыре пробела вместо табуляции, так что здесь единообразия нет. Нажатие Enter ⏎ в редакторе создаёт новую строку кода , то есть физически делит текст программы на строки. Код не реагирует на простой Enter, если инструкция не закончена. Но если вы начали блок (например, if), то новая строка должна иметь правильный отступ.

Большинству языков программирования всё равно на пробелы и переводы строк, кроме случаев, когда они разделяют ключевые слова, операторы или идентификаторы. Исключение - Python, там отступы обязательны. Но обычные пробелы внутри строки или вокруг операторов — не влияют на выполнение.

Используйте автоформатирование в IDE (VS Code, PyCharm и др.) — он поможет соблюдать стиль.